package com.educatioin.manage.utils;

import com.educatioin.manage.constant.OrderStatus;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 合法性校验工具
 * 
 * @author Administrator
 *
 */
public class ValidatorUtil {

	/**
	 * 功能：手机号验证
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isMobile(String str) {
		Pattern p = null;
		Matcher m = null;
		boolean b = false;
		if (StringUtils.isBlank(str)) {
			return b;
		}
		p = Pattern.compile("^[1][3,4,5,6,7,8,9][0-9]{9}$"); // 验证手机号
		m = p.matcher(str);
		b = m.matches();
		return b;

	}

	/**
	 * 功能：数字判断
	 * @param str
	 * @return
	 */
	public static boolean isNumeric(String str) {
		if (StringUtils.isBlank(str)) {
			return false;
		}
		
		if (str.matches("\\d*")) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 判断是否是长整数
	 * @param str
	 * @return
	 */
	public static boolean isLong(String str){
        boolean b = true;
        try{
                Long.valueOf(str);
        }catch(Exception e){
                 b = false;
        }
        return b;
    }
	
	/**
	 * 判断密码格式是否正确(只能是数组或者字母，并存长度为[6,12])
	 * @param passwd
	 * @return
	 * @author wyongjian
	 * @date 2014-11-18
	 */
	public static boolean isPasswd(String passwd){
		if(StringUtils.isBlank(passwd))return false;
		if(passwd.length()<6 || passwd.length()>12)return false;
		String regEx="^[A-Za-z0-9_]+$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(passwd);
	    return m.matches();
	}
	
	/**
	 * 判断是否是IPv4
	 * @param input
	 * @return
	 */
	public static boolean isIPv4Address(String input) {
		Pattern IPV4_PATTERN = Pattern
				.compile("^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$");
		return IPV4_PATTERN.matcher(input).matches();
	}
	
	/**
	 * 判断是否是MAC地址
	 * @param mac
	 * @return
	 * @author wyongjian
	 * @date 2014-11-26
	 */
	public static boolean isMac(String mac){
		if(StringUtils.isNotBlank(mac)){
			mac = mac.toUpperCase();
			
			//正则校验MAC合法性  
		    String patternMac="^[A-F0-9]{2}(:[A-F0-9]{2}){5}$";  
		    if(Pattern.compile(patternMac).matcher(mac).find()){  
		    	return true;
	        } 
		}
	    return false;
	}

	/**
	 * 判断用户名格式是否正确(以字母开头，只能包含数字、字母或者下划线，长度不超过20)
	 * @param username
	 * @return
	 */
	public static boolean isUsername(String username){
		if(StringUtils.isBlank(username))return false;
		if(username.length()>20)return false;
		String regEx="^[A-Za-z][A-Za-z0-9_]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(username);
	    return m.matches();
	}
	
	/**
	 * 判断扩展字段key格式是否正确(只允许字母与下划线表示，其中只能使用字母开头，最长20字符)
	 * @param key
	 * @return
	 */
	public static boolean isExInfoKeyValid(String key){
		if(StringUtils.isBlank(key))return false;
		if(key.length()>20)return false;
		String regEx="^[A-Za-z][A-Za-z0-9_]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(key);
	    return m.matches();
	}
	
	/**
	 * 判断领域扩展字段key格式是否正确(只允许字母与下划线表示，其中只能使用字母开头)
	 * @param key
	 * @return
	 */
	public static boolean isRealmExInfoKeyValid(String key){
		if(StringUtils.isBlank(key))return false;
		String regEx="^[A-Za-z][A-Za-z0-9_]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(key);
	    return m.matches();
	}
	
	/**
	 * 判断扩展字段key格式是否正确(只允许字母与下划线表示，其中只能使用字母开头，最长20字符)
	 * @param exinfoMap
	 * @return
	 */
	public static boolean isExInfoKeyValid(Map<String, Object> exinfoMap){
		if(CollectionUtils.isEmpty(exinfoMap))
			return true;
		
		for(Map.Entry<String, Object> entry : exinfoMap.entrySet()){
			if(!isExInfoKeyValid(entry.getKey()))
				return false;
		}
		
		return true;
	}
	
	/**
	 * 用户邻域扩展key校验
	 * @param exinfoMap
	 * @return
	 */
	public static boolean isUserRealmExInfoKeyValid(Map<String, Object> exinfoMap){
		if(CollectionUtils.isEmpty(exinfoMap))
			return true;
		
		String[] keys = null;
		for(Map.Entry<String, Object> entry : exinfoMap.entrySet()){
			if(StringUtils.isBlank(entry.getKey()))return false;
			if(entry.getKey().length()>100)return false;
			
			keys = entry.getKey().split("\\.");
			if(null == keys || keys.length <=1)
				return false;
			
			for(int i=0; i<keys.length;++i){
				if(!isRealmExInfoKeyValid(keys[i]))
					return false;
			}			
		}
		
		return true;
	}
	
	/**
	 * 判断组织名格式是否正确(包括字母数字_标示，最长50字符)
	 * @param
	 * @return
	 */
	public static boolean isOrgNameValid(String orgName){
		if(StringUtils.isBlank(orgName))return false;
		if(orgName.length()>50)return false;
		String regEx="^[A-Za-z0-9_]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(orgName);
	    return m.matches();
	}
	
	/**
	 * 字符串是否包含中文
	 * @param source
	 * @return
	 */
	public static boolean isContainsChinese(String source){
		final String regEx = "[\u4e00-\u9fa5]";
		final Pattern pat = Pattern.compile(regEx);
		boolean flag = false;
		Matcher matcher = pat.matcher(source);
		if(matcher.find()) {
			flag = true;
		}
		return flag;
	}

	/**
	 *  验证是否包含4个字节的字符(如:emoji表情)
	 *
	 * @param s
	 * @return
	 * @since
	 */
	public static boolean isMb4(String s) {
		int len = s.length();
		return len != s.codePointCount(0, len);
	}
	
	/**
	 * 判断工号或学号格式是否正确(可包括字母、数字、_、.、@，最长50字符)
	 * @param
	 * @return
	 */
	public static boolean isOrgUserCodeValid(String orgUserCode){
		if(StringUtils.isBlank(orgUserCode))return false;
		if(orgUserCode.length()>50)return false;
		if(isMobile(orgUserCode))return false;
		
		String regEx="^[A-Za-z0-9_@.]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(orgUserCode);
	    return m.matches();
	}
	
	/**
	 * 判断登录名格式是否正确(可包括字母、数字、_、.、@，最长50字符)
	 * @param
	 * @return
	 */
	public static boolean isLoginNameValid(String loginName){
		if(StringUtils.isBlank(loginName))return false;
		if(loginName.length()>50)return false;
		String regEx="^[A-Za-z0-9_@.\\-]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(loginName);
	    return m.matches();
	}
	
	/**
	 * 判断昵称是否正确(长度不超过50)
	 * @param
	 * @return
	 */
	public static boolean isNickNameValid(String nickName){
		if(null == nickName || nickName.length()>50 || (!nickName.isEmpty() && nickName.trim().isEmpty()))
			return false;
		
	    return true;
	}
	
	/**
	 * 判断节点名称是否正确(长度不超过200)
	 * @param
	 * @return
	 */
	public static boolean isNodeNameValid(String nodeName){
		if(StringUtils.isBlank(nodeName))return false;
		if(nodeName.length()>100)return false;
		
	    return true;
	}
	
	/**
	 * 判断真实姓名是否正确(长度不超过50)
	 * @param
	 * @return
	 */
	public static boolean isRealNameValid(String realName){
		if(StringUtils.isBlank(realName))return false;
		if(realName.length()>50)return false;
		//检查是否存在emoji表情
		if(isEmoji(realName)){
		    return false;
		}
	    return true;
	}
	
	/**
	 * 判断组织全称是否正确(长度不超过200)
	 * @param
	 * @return
	 */
	public static boolean isOrgFullNameValid(String orgFullName){
		if(StringUtils.isBlank(orgFullName))return false;
		if(orgFullName.length()>100)return false;
		
	    return true;
	}
	
	
	/**
	 * 判断短信内容是否合法
	 * @param
	 * @return
	 */
	public static boolean isSmsContentValid(String smsContet){
		if(StringUtils.isBlank(smsContet))return false;
		if(smsContet.length()>70)return false;
		if(smsContet.contains("【") || smsContet.contains("】") || smsContet.contains("{") || smsContet.contains("}") || 
		   smsContet.contains("[") || smsContet.contains("]"))return false;
		if(!smsContet.contains("%1$s"))return false;
		
	    return true;
	}

	/**
	 * 判断offset是否有效
	 * @param offset
	 * @return
	 */
	public static boolean isOffsetValid(Integer offset) {
		if (offset <0){
			return false;
		}else{
			return true;
		}
	}
	
	
	/**
	 * 判断角色名称格式是否正确(以字母开头，只能包含字母或者下划线，长度不超过50)
	 * @param
	 * @return
	 */
	public static boolean isRoleNameValid(String roleName){
		if(StringUtils.isBlank(roleName))return false;
		if(roleName.length()>50)return false;
		String regEx="^[A-Za-z][A-Za-z0-9_]*$";
	    Pattern p=Pattern.compile(regEx);
	    Matcher m=p.matcher(roleName);
	    return m.matches();
	}
	
	/**
	 * 判断关键字是否有效
	 * @param key
	 * @return
	 */
	public static boolean isKeyValid(String key){
		if(StringUtils.isBlank(key)) return false;
		if(key.contains("%")) return false;
		
		return true;
	}

	/**
	 * 判断desc是否有效
	 * @param desc
	 * @return
	 */
	public static boolean isDescValid(String desc){
		if(StringUtils.isBlank(desc) || desc.length() <= 500){
			return true;
		}

		return false;
	}
	
	/**
     * 功能：国际区号验证
     * 
     * @param str
     * @return
     */
    public static boolean isCountryCodeValid(String str) {
        if(StringUtils.isNotBlank(str)){
            if(str.length()>16){
                return false;
            }
            Pattern p = null;
            Matcher m = null;
            boolean b = false;
            p = Pattern.compile("^[\\+][0-9]*$"); // 验证国际区号
            m = p.matcher(str);
            b = m.matches();
            return b;
        }
        return true;
    }
    
	
	/**
	 * 判断是否是UC的预留扩展属性
	 * @param orgExinfo
	 * @return
	 */
	/*public static boolean isUcReserveAttr(Map<String, Object> orgExinfo){
		if(CollectionUtils.isEmpty(orgExinfo))
			return false;
		
		if(orgExinfo.containsKey("org_id") || orgExinfo.containsKey("org_name") || orgExinfo.containsKey("node_id") || orgExinfo.containsKey("node_name") || 
		   orgExinfo.containsKey("node_items") || (orgExinfo.containsKey("current_node"))) {
			return true;
		}
		
		return false;
	}*/
	
	/**
	 * 判断是否是UC的预留扩展属性
	 * @param orgExinfo
	 * @return
	 */
	public static void filterUcReserveAttr(Map<String, Object> orgExinfo){
		if(!CollectionUtils.isEmpty(orgExinfo)){
			orgExinfo.remove("org_id");
			orgExinfo.remove("node_id");
			orgExinfo.remove("org_name");
			orgExinfo.remove("node_name");
			orgExinfo.remove("node_items");
			orgExinfo.remove("current_node");
			orgExinfo.remove("v_org_id");
		}
	}
	
    /**
    * 功能：邮箱验证
    * 
    * @param str
    * @return
    */
    public static boolean isEmailValid(String str) {
        Pattern p = null;
        Matcher m = null;
        boolean b = false;
        if (StringUtils.isBlank(str)) {
            return b;
        }else if(str.length() > 100){
            return b;
        }
        p = Pattern.compile("^(\\w)+(\\.\\w+)*@(\\w)+((\\.\\w+)+)$"); // 验证邮箱地址
        m = p.matcher(str);
        b = m.matches();
        return b;
    }
    
    /**
     * 判断邮箱验证码内容是否合法
     * @param emailContent
     * @return
     */
    public static boolean isEmailContentValid(String emailContent){
        if(StringUtils.isBlank(emailContent))return false;
        if(emailContent.length()>1000)return false;
        if(emailContent.contains("%1$s") && emailContent.contains("%2$s") ){
            return true;
        }
        
        return false;
    }
    
    /**
     * 判断订单类型是否合法
     * @param
     * @return
     */
    public static boolean isOrderStatusValid(Integer orderStatus) {
    	if(null == orderStatus)
    		return false;
    	
    	OrderStatus type = OrderStatus.valueOf(orderStatus);
    	if(null == type){
            return false;
        }
        
        return true;
    }

    /**
     * 判断业务方邮件链接跳转地址是否有效	
     * <p>Description:              </p>
     * <p>Create Time: 2016年6月21日   </p>
     * <p>Create author: Administrator   </p>
     * @param appUri
     * @return
     */
    public static boolean isAppUriValid(String appUri) {
        if(StringUtils.isBlank(appUri) || (!appUri.startsWith("http:") && !appUri.startsWith("https:")) ){
            return false;
        }
        return true;
    }

    /**
     * 判断过期时间参数是否正确	
     * <p>Description:              </p>
     * <p>Create Time: 2016年6月23日   </p>
     * <p>Create author: Administrator   </p>
     * @param expireTime
     * @return
     */
    public static boolean isExpireTimeValid(Integer expireTime) {
        if(expireTime.intValue() <1){
            return false;
        }else{
            return true;
        }
    }

    /**
     * 检查字符是否是emoji字符
     * 
     * @param
     * @return
     * @since
     */
	private static boolean isEmoji(String source) {
		boolean flag = false;
		Matcher matcher = Pattern.compile("[\\ud800\\udc00-\\udbff\\udfff\\ud800-\\udfff]").matcher(source);
		if(matcher.find()) {
			flag = true;
		}

		return flag;
	}

	public static boolean isBirthday(String birthday) {
		if (StringUtils.isBlank(birthday))
			return false;
		if(birthday.length()>20)return false;
		//月份为 1, 3, 5, 7, 8, 10, 12，天数范围为 01 - 31
		String regEx0="(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01])";
		Pattern p0=Pattern.compile(regEx0);
		Matcher m0=p0.matcher(birthday);
		boolean r0 = m0.matches();
		//月份为 4, 6, 9, 11，天数范围为 01-30
		String regEx1="(0[469]|11)-(0[1-9]|[12][0-9]|30)";
		Pattern p1=Pattern.compile(regEx1);
		Matcher m1=p1.matcher(birthday);
		boolean r1 = m1.matches();
		//月份为 2
		String regEx2="02-(0[1-9]|[1][0-9]|2[0-9])";
		Pattern p2=Pattern.compile(regEx2);
		Matcher m2=p2.matcher(birthday);
		boolean r2 = m2.matches();
		return r0 || r1 || r2;
	}

}
